Face Generation¶

In this project, you'll use generative adversarial networks to generate new images of faces.

Get the Data¶

You'll be using two datasets in this project:

MNIST
CelebA

Since the celebA dataset is complex and you're doing GANs in a project for the first time, we want you to test your neural network on MNIST before CelebA. Running the GANs on MNIST will allow you to see how well your model trains sooner.

If you're using FloydHub, set data_dir to "/input" and use the FloydHub data ID "R5KrjnANiKVhLWAkpXhNBe".

#data_dir = './data'

# FloydHub - Use with data ID "R5KrjnANiKVhLWAkpXhNBe"
data_dir = '/input'


"""
DON'T MODIFY ANYTHING IN THIS CELL
"""
import helper

helper.download_extract('mnist', data_dir)
helper.download_extract('celeba', data_dir)

Downloading mnist: 9.92MB [00:01, 8.01MB/s]                            
Extracting mnist: 100%|██████████| 60.0K/60.0K [00:11<00:00, 5.23KFile/s]
Downloading celeba: 1.44GB [08:56, 2.69MB/s]

Extracting celeba...

Explore the Data¶

MNIST¶

As you're aware, the MNIST dataset contains images of handwritten digits. You can view the first number of examples by changing show_n_images.

show_n_images = 25

"""
DON'T MODIFY ANYTHING IN THIS CELL
"""
%matplotlib inline
import os
from glob import glob
from matplotlib import pyplot

mnist_images = helper.get_batch(glob(os.path.join(data_dir, 'mnist/*.jpg'))[:show_n_images], 28, 28, 'L')
pyplot.imshow(helper.images_square_grid(mnist_images, 'L'), cmap='gray')

<matplotlib.image.AxesImage at 0x7f00a5203080>

CelebA¶

The CelebFaces Attributes Dataset (CelebA) dataset contains over 200,000 celebrity images with annotations. Since you're going to be generating faces, you won't need the annotations. You can view the first number of examples by changing show_n_images.

show_n_images = 25

"""
DON'T MODIFY ANYTHING IN THIS CELL
"""
mnist_images = helper.get_batch(glob(os.path.join(data_dir, 'img_align_celeba/*.jpg'))[:show_n_images], 28, 28, 'RGB')
pyplot.imshow(helper.images_square_grid(mnist_images, 'RGB'))

<matplotlib.image.AxesImage at 0x7f00a5136b00>

Preprocess the Data¶

Since the project's main focus is on building the GANs, we'll preprocess the data for you. The values of the MNIST and CelebA dataset will be in the range of -0.5 to 0.5 of 28x28 dimensional images. The CelebA images will be cropped to remove parts of the image that don't include a face, then resized down to 28x28.

The MNIST images are black and white images with a single color channel while the CelebA images have 3 color channels (RGB color channel).

Build the Neural Network¶

You'll build the components necessary to build a GANs by implementing the following functions below:

model_inputs
discriminator
generator
model_loss
model_opt
train

Check the Version of TensorFlow and Access to GPU¶

This will check to make sure you have the correct version of TensorFlow and access to a GPU

"""
DON'T MODIFY ANYTHING IN THIS CELL
"""
from distutils.version import LooseVersion
import warnings
import tensorflow as tf

# Check TensorFlow Version
assert LooseVersion(tf.__version__) >= LooseVersion('1.0'), 'Please use TensorFlow version 1.0 or newer.  You are using {}'.format(tf.__version__)
print('TensorFlow Version: {}'.format(tf.__version__))

# Check for a GPU
if not tf.test.gpu_device_name():
    warnings.warn('No GPU found. Please use a GPU to train your neural network.')
else:
    print('Default GPU Device: {}'.format(tf.test.gpu_device_name()))

TensorFlow Version: 1.1.0
Default GPU Device: /gpu:0

Input¶

Implement the model_inputs function to create TF Placeholders for the Neural Network. It should create the following placeholders:

Real input images placeholder with rank 4 using image_width, image_height, and image_channels.
Z input placeholder with rank 2 using z_dim.
Learning rate placeholder with rank 0.

Return the placeholders in the following the tuple (tensor of real input images, tensor of z data)

import problem_unittests as tests

def model_inputs(image_width, image_height, image_channels, z_dim):
    """
    Create the model inputs
    :param image_width: The input image width
    :param image_height: The input image height
    :param image_channels: The number of image channels
    :param z_dim: The dimension of Z
    :return: Tuple of (tensor of real input images, tensor of z data, learning rate)
    """
    # TODO: Implement Function
    real_input_images = tf.placeholder(dtype=tf.float32,shape = [None,image_width,image_height,image_channels])
    z_data = tf.placeholder(dtype=tf.float32,shape = [None,z_dim])
    lr = tf.placeholder(dtype=tf.float32,name="learning_rate")
    return real_input_images, z_data, lr


"""
DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
"""
tests.test_model_inputs(model_inputs)

Tests Passed

Discriminator¶

Implement discriminator to create a discriminator neural network that discriminates on images. This function should be able to reuse the variables in the neural network. Use tf.variable_scope with a scope name of "discriminator" to allow the variables to be reused. The function should return a tuple of (tensor output of the discriminator, tensor logits of the discriminator).

def discriminator(images, reuse=False,alpha = 0.2):
    """
    Create the discriminator network
    :param images: Tensor of input image(s)
    :param reuse: Boolean if the weights should be reused
    :return: Tuple of (tensor output of the discriminator, tensor logits of the discriminator)
    """
    # TODO: Implement Function
    
    xav_init = tf.contrib.layers.xavier_initializer()
    keep_prob = 0.5
    with tf.variable_scope("discriminator", reuse=reuse):
        # Input layer is 32x32x3
        x1 = tf.layers.conv2d(images, 64, 5, strides=2, padding='same',kernel_initializer = xav_init)
        x1 = tf.layers.dropout(x1, rate=(keep_prob), training=True)
        relu1 = tf.maximum(alpha * x1, x1)
        # 16x16x64
        
        x2 = tf.layers.conv2d(relu1, 128, 5, strides=2, padding='same',kernel_initializer = xav_init)
        x2 = tf.layers.dropout(x2, rate=(keep_prob), training=True)
        bn2 = tf.layers.batch_normalization(x2, training=True)
        relu2 = tf.maximum(alpha * bn2, bn2)
        # 8x8x128
        
        x3 = tf.layers.conv2d(relu2, 256, 5, strides=2, padding='same',kernel_initializer = xav_init)
        x3 = tf.layers.dropout(x3, rate=(keep_prob), training=True)
        bn3 = tf.layers.batch_normalization(x3, training=True)
        relu3 = tf.maximum(alpha * bn3, bn3)
        # 4x4x256

        # Flatten it
        flat = tf.reshape(relu3, (-1, 4*4*256))
        logits = tf.layers.dense(flat, 1)
        out = tf.sigmoid(logits)
        
        return out, logits


"""
DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
"""
tests.test_discriminator(discriminator, tf)

Tests Passed

Generator¶

Implement generator to generate an image using z. This function should be able to reuse the variables in the neural network. Use tf.variable_scope with a scope name of "generator" to allow the variables to be reused. The function should return the generated 28 x 28 x out_channel_dim images.

def generator(z, out_channel_dim, is_train=True,alpha = 0.20):
    """
    Create the generator network
    :param z: Input z
    :param out_channel_dim: The number of channels in the output image
    :param is_train: Boolean if generator is being used for training
    :return: The tensor output of the generator
    """
    # TODO: Implement Function
    reuse_state = not is_train
    xav = tf.contrib.layers.xavier_initializer()
    keep_prob = 0.5
    with tf.variable_scope('generator', reuse=reuse_state):
         # First fully connected layer
        x1 = tf.layers.dense(z, 4*4*256)
        # Reshape it to start the convolutional stack
        x1 = tf.reshape(x1, (-1, 4, 4, 256))
        x1 = tf.layers.dropout(x1, rate=(keep_prob), training=True)
        x1 = tf.layers.batch_normalization(x1, training=is_train)
        x1 = tf.maximum(alpha * x1, x1)
        # print(x1.shape)
        # 4x4x256 now
        #change from 5 to 4 below
        x2 = tf.layers.conv2d_transpose(x1, 128, 4, strides=1, padding='valid', kernel_initializer=xav)
        x2 = tf.layers.dropout(x2, rate=(keep_prob), training=True)
        x2 = tf.layers.batch_normalization(x2, training=is_train)
        x2 = tf.maximum(alpha * x2, x2)
        # print(x2.shape)
        # 7x7x128 now
        
        x3 = tf.layers.conv2d_transpose(x2, 64, 5, strides=2, padding='same', kernel_initializer=xav)
        x3 = tf.layers.dropout(x3, rate=(keep_prob), training=True)
        x3 = tf.layers.batch_normalization(x3, training=is_train)
        x3 = tf.maximum(alpha * x3, x3)
        
        x4 = tf.layers.conv2d_transpose(x2, 32, 5, strides=2, padding='same', kernel_initializer=xav)
        x4 = tf.layers.dropout(x4, rate=(keep_prob), training=True)
        x4 = tf.layers.batch_normalization(x4, training=is_train)
        x4 = tf.maximum(alpha * x4, x4)
        # print(x3.shape)
        # 14x14x64 now
        
        # Output layer
        logits = tf.layers.conv2d_transpose(x4, out_channel_dim, 5, strides=2, padding='same', kernel_initializer=xav)
        # print(logits.shape)
        # 28x28x5 now
        
        out = tf.tanh(logits)
        
        return out

"""
DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
"""
tests.test_generator(generator, tf)

Tests Passed

Loss¶

Implement model_loss to build the GANs for training and calculate the loss. The function should return a tuple of (discriminator loss, generator loss). Use the following functions you implemented:

discriminator(images, reuse=False)
generator(z, out_channel_dim, is_train=True)

def model_loss(input_real, input_z, out_channel_dim, alpha = 0.2):
    """
    Get the loss for the discriminator and generator
    :param input_real: Images from the real dataset
    :param input_z: Z input
    :param out_channel_dim: The number of channels in the output image
    :return: A tuple of (discriminator loss, generator loss)
    """
    # TODO: Implement Function
    smoothing = 0.9
    g_model = generator(input_z, out_channel_dim, alpha=alpha)
    d_model_real, d_logits_real = discriminator(input_real, alpha=alpha)
    d_model_fake, d_logits_fake = discriminator(g_model, reuse=True, alpha=alpha)
    
    d_loss_real = tf.reduce_mean(
        tf.nn.sigmoid_cross_entropy_with_logits(logits=d_logits_real
                                                #,labels= tf.fill(d_logits_real.get_shape(), smoothing)
                                                ,labels= tf.ones_like(d_model_real)*smoothing))
    d_loss_fake = tf.reduce_mean(
        tf.nn.sigmoid_cross_entropy_with_logits(logits=d_logits_fake
                                                ,labels=tf.zeros_like(d_model_fake)))
    g_loss = tf.reduce_mean(
        tf.nn.sigmoid_cross_entropy_with_logits(logits=d_logits_fake
                                                ,labels=tf.ones_like(d_model_fake)))

    d_loss = d_loss_real + d_loss_fake

    return d_loss, g_loss

Optimization¶

Implement model_opt to create the optimization operations for the GANs. Use tf.trainable_variables to get all the trainable variables. Filter the variables with names that are in the discriminator and generator scope names. The function should return a tuple of (discriminator training operation, generator training operation).

def model_opt(d_loss, g_loss, learning_rate, beta1):
    """
    Get optimization operations
    :param d_loss: Discriminator loss Tensor
    :param g_loss: Generator loss Tensor
    :param learning_rate: Learning Rate Placeholder
    :param beta1: The exponential decay rate for the 1st moment in the optimizer
    :return: A tuple of (discriminator training operation, generator training operation)
    """
    # TODO: Implement Function
    t_vars = tf.trainable_variables()
    d_vars = [var for var in t_vars if var.name.startswith('discriminator')]
    g_vars = [var for var in t_vars if var.name.startswith('generator')]

    # Optimize
    with tf.control_dependencies(tf.get_collection(tf.GraphKeys.UPDATE_OPS)):
        d_train_opt = tf.train.AdamOptimizer(learning_rate, beta1=beta1).minimize(d_loss, var_list=d_vars)
        g_train_opt = tf.train.AdamOptimizer(learning_rate, beta1=beta1).minimize(g_loss, var_list=g_vars)

    return d_train_opt, g_train_opt


"""
DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
"""
tests.test_model_opt(model_opt, tf)

Tests Passed

Neural Network Training¶

Show Output¶

Use this function to show the current output of the generator during training. It will help you determine how well the GANs is training.

"""
DON'T MODIFY ANYTHING IN THIS CELL
"""
import numpy as np

def show_generator_output(sess, n_images, input_z, out_channel_dim, image_mode):
    """
    Show example output for the generator
    :param sess: TensorFlow session
    :param n_images: Number of Images to display
    :param input_z: Input Z Tensor
    :param out_channel_dim: The number of channels in the output image
    :param image_mode: The mode to use for images ("RGB" or "L")
    """
    cmap = None if image_mode == 'RGB' else 'gray'
    z_dim = input_z.get_shape().as_list()[-1]
    example_z = np.random.uniform(-1, 1, size=[n_images, z_dim])

    samples = sess.run(
        generator(input_z, out_channel_dim, False),
        feed_dict={input_z: example_z})

    images_grid = helper.images_square_grid(samples, image_mode)
    pyplot.imshow(images_grid, cmap=cmap)
    pyplot.show()

Train¶

Implement train to build and train the GANs. Use the following functions you implemented:

model_inputs(image_width, image_height, image_channels, z_dim)
model_loss(input_real, input_z, out_channel_dim)
model_opt(d_loss, g_loss, learning_rate, beta1)

Use the show_generator_output to show generator output while you train. Running show_generator_output for every batch will drastically increase training time and increase the size of the notebook. It's recommended to print the generator output every 100 batches.

def train(epoch_count, batch_size, z_dim, learning_rate, beta1, get_batches, data_shape, data_image_mode):
    """
    Train the GAN
    :param epoch_count: Number of epochs
    :param batch_size: Batch Size
    :param z_dim: Z dimension
    :param learning_rate: Learning Rate
    :param beta1: The exponential decay rate for the 1st moment in the optimizer
    :param get_batches: Function to get batches
    :param data_shape: Shape of the data
    :param data_image_mode: The image mode to use for images ("RGB" or "L")
    """
    # TODO: Build Model
    _, img_height, img_width, img_channel = data_shape    
    inputs_real, inputs_z, lr = model_inputs(img_height, img_width, img_channel, z_dim)
    
    d_loss, g_loss = model_loss(inputs_real, inputs_z, img_channel)
    d_opt, g_opt = model_opt(d_loss, g_loss, lr, beta1)
    
    losses = []
    steps = 0
    
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
        for epoch_i in range(epoch_count):
            for batch_images in get_batches(batch_size):
                # TODO: Train Model
                steps += 1
                
                # Convert the images values from -.5, .5 to -1, 1
                batch_images *= 2
                
                batch_z = np.random.uniform(-1, 1, size=[batch_size, z_dim])
                
                # Run optimizers
                sess.run(d_opt, feed_dict={inputs_real: batch_images, inputs_z: batch_z, lr: learning_rate})
                sess.run(g_opt, feed_dict={inputs_real: batch_images, inputs_z: batch_z, lr: learning_rate})
                sess.run(g_opt, feed_dict={inputs_real: batch_images, inputs_z: batch_z, lr: learning_rate})
    
                # Show the loss every 10 steps
                if steps % 10 == 0:
                    train_loss_d = d_loss.eval({inputs_real: batch_images, inputs_z: batch_z})
                    train_loss_g = g_loss.eval({inputs_z: batch_z})
                    
                    print('Epoch: {}/{}'.format(epoch_i + 1, epoch_count),
                          'Discriminator Loss: {}'.format(train_loss_d),
                          'Generator Loss: {}'.format(train_loss_g))
                    
                    # Save the losses to view after training
                    losses.append((train_loss_d, train_loss_g))
                
                # Show the generator ouput every 100 steps
                if steps % 100 == 0:
                    show_generator_output(sess, 25, inputs_z, data_shape[3], data_image_mode)
    
    return losses

MNIST¶

Test your GANs architecture on MNIST. After 2 epochs, the GANs should be able to generate images that look like handwritten digits. Make sure the loss of the generator is lower than the loss of the discriminator or close to 0.

batch_size = 32
z_dim = 100
learning_rate = 0.0005
beta1 = 0.5


"""
DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
"""
epochs = 2

mnist_dataset = helper.Dataset('mnist', glob(os.path.join(data_dir, 'mnist/*.jpg')))
with tf.Graph().as_default():
    train(epochs, batch_size, z_dim, learning_rate, beta1, mnist_dataset.get_batches,
          mnist_dataset.shape, mnist_dataset.image_mode)

Epoch: 1/2 Discriminator Loss: 1.3702822923660278 Generator Loss: 0.8103255033493042
Epoch: 1/2 Discriminator Loss: 1.519286870956421 Generator Loss: 0.8017351627349854
Epoch: 1/2 Discriminator Loss: 1.5324488878250122 Generator Loss: 0.5075470805168152
Epoch: 1/2 Discriminator Loss: 1.321492075920105 Generator Loss: 1.288707971572876
Epoch: 1/2 Discriminator Loss: 1.2174973487854004 Generator Loss: 1.3117433786392212
Epoch: 1/2 Discriminator Loss: 1.279130458831787 Generator Loss: 1.022763967514038
Epoch: 1/2 Discriminator Loss: 1.4794611930847168 Generator Loss: 0.8380999565124512
Epoch: 1/2 Discriminator Loss: 1.1748906373977661 Generator Loss: 2.161454200744629
Epoch: 1/2 Discriminator Loss: 1.4156677722930908 Generator Loss: 1.407326102256775
Epoch: 1/2 Discriminator Loss: 1.2081525325775146 Generator Loss: 1.476306676864624

Epoch: 1/2 Discriminator Loss: 1.308555245399475 Generator Loss: 0.8345716595649719
Epoch: 1/2 Discriminator Loss: 1.1789580583572388 Generator Loss: 2.203615188598633
Epoch: 1/2 Discriminator Loss: 1.2146971225738525 Generator Loss: 1.1539051532745361
Epoch: 1/2 Discriminator Loss: 1.3455545902252197 Generator Loss: 1.2768938541412354
Epoch: 1/2 Discriminator Loss: 1.1189956665039062 Generator Loss: 0.910425066947937
Epoch: 1/2 Discriminator Loss: 1.4037013053894043 Generator Loss: 1.6171860694885254
Epoch: 1/2 Discriminator Loss: 1.2356094121932983 Generator Loss: 1.3518630266189575
Epoch: 1/2 Discriminator Loss: 1.4548767805099487 Generator Loss: 1.1609796285629272
Epoch: 1/2 Discriminator Loss: 1.3045574426651 Generator Loss: 0.8996471166610718
Epoch: 1/2 Discriminator Loss: 1.459968090057373 Generator Loss: 1.3977376222610474

Epoch: 1/2 Discriminator Loss: 1.1112635135650635 Generator Loss: 1.03603196144104
Epoch: 1/2 Discriminator Loss: 1.6211521625518799 Generator Loss: 1.6247860193252563
Epoch: 1/2 Discriminator Loss: 1.109370231628418 Generator Loss: 1.083580493927002
Epoch: 1/2 Discriminator Loss: 1.132751703262329 Generator Loss: 1.0390846729278564
Epoch: 1/2 Discriminator Loss: 1.106766700744629 Generator Loss: 1.2393428087234497
Epoch: 1/2 Discriminator Loss: 1.1471589803695679 Generator Loss: 1.3624367713928223
Epoch: 1/2 Discriminator Loss: 1.6329143047332764 Generator Loss: 1.256222128868103
Epoch: 1/2 Discriminator Loss: 1.2894452810287476 Generator Loss: 0.9949078559875488
Epoch: 1/2 Discriminator Loss: 1.2306602001190186 Generator Loss: 1.1251435279846191
Epoch: 1/2 Discriminator Loss: 1.6354260444641113 Generator Loss: 0.8505319952964783

Epoch: 1/2 Discriminator Loss: 1.4078552722930908 Generator Loss: 1.0221937894821167
Epoch: 1/2 Discriminator Loss: 1.3475160598754883 Generator Loss: 0.9486749172210693
Epoch: 1/2 Discriminator Loss: 1.3329014778137207 Generator Loss: 1.4034740924835205
Epoch: 1/2 Discriminator Loss: 1.5971953868865967 Generator Loss: 0.6669455766677856
Epoch: 1/2 Discriminator Loss: 1.398836374282837 Generator Loss: 1.0489248037338257
Epoch: 1/2 Discriminator Loss: 1.1346021890640259 Generator Loss: 1.0502835512161255
Epoch: 1/2 Discriminator Loss: 1.3143945932388306 Generator Loss: 1.4823298454284668
Epoch: 1/2 Discriminator Loss: 1.0013223886489868 Generator Loss: 1.2283563613891602
Epoch: 1/2 Discriminator Loss: 1.1027240753173828 Generator Loss: 1.5784602165222168
Epoch: 1/2 Discriminator Loss: 1.2998895645141602 Generator Loss: 1.007387638092041

Epoch: 1/2 Discriminator Loss: 1.2740837335586548 Generator Loss: 1.1959657669067383
Epoch: 1/2 Discriminator Loss: 1.5901362895965576 Generator Loss: 0.7763429284095764
Epoch: 1/2 Discriminator Loss: 1.3150464296340942 Generator Loss: 1.2196695804595947
Epoch: 1/2 Discriminator Loss: 1.2648612260818481 Generator Loss: 1.110962152481079
Epoch: 1/2 Discriminator Loss: 1.474158525466919 Generator Loss: 1.0213613510131836
Epoch: 1/2 Discriminator Loss: 1.3482552766799927 Generator Loss: 1.156524419784546
Epoch: 1/2 Discriminator Loss: 1.1579313278198242 Generator Loss: 1.1567704677581787
Epoch: 1/2 Discriminator Loss: 1.235907793045044 Generator Loss: 0.9428659081459045
Epoch: 1/2 Discriminator Loss: 1.297568678855896 Generator Loss: 1.0123796463012695
Epoch: 1/2 Discriminator Loss: 1.137377381324768 Generator Loss: 1.2816498279571533

Epoch: 1/2 Discriminator Loss: 1.1336545944213867 Generator Loss: 1.0090501308441162
Epoch: 1/2 Discriminator Loss: 1.4417959451675415 Generator Loss: 0.6533852219581604
Epoch: 1/2 Discriminator Loss: 1.2280454635620117 Generator Loss: 0.9757595062255859
Epoch: 1/2 Discriminator Loss: 1.413022518157959 Generator Loss: 0.700104296207428
Epoch: 1/2 Discriminator Loss: 1.1793532371520996 Generator Loss: 1.06399405002594
Epoch: 1/2 Discriminator Loss: 1.4496479034423828 Generator Loss: 0.757703423500061
Epoch: 1/2 Discriminator Loss: 1.292140245437622 Generator Loss: 0.7694442272186279
Epoch: 1/2 Discriminator Loss: 1.2490720748901367 Generator Loss: 1.2063710689544678
Epoch: 1/2 Discriminator Loss: 1.2464280128479004 Generator Loss: 1.0410714149475098
Epoch: 1/2 Discriminator Loss: 1.390529990196228 Generator Loss: 0.9119998216629028

Epoch: 1/2 Discriminator Loss: 1.1466888189315796 Generator Loss: 1.2078073024749756
Epoch: 1/2 Discriminator Loss: 1.2851274013519287 Generator Loss: 1.2086377143859863
Epoch: 1/2 Discriminator Loss: 1.0988261699676514 Generator Loss: 0.8627527952194214
Epoch: 1/2 Discriminator Loss: 1.409559965133667 Generator Loss: 1.1244595050811768
Epoch: 1/2 Discriminator Loss: 1.2057937383651733 Generator Loss: 1.4305095672607422
Epoch: 1/2 Discriminator Loss: 1.1865124702453613 Generator Loss: 1.1009654998779297
Epoch: 1/2 Discriminator Loss: 1.353835105895996 Generator Loss: 0.8939172625541687
Epoch: 1/2 Discriminator Loss: 1.308343529701233 Generator Loss: 0.9628197550773621
Epoch: 1/2 Discriminator Loss: 1.1671063899993896 Generator Loss: 1.0879573822021484
Epoch: 1/2 Discriminator Loss: 1.374017596244812 Generator Loss: 0.7480915784835815

Epoch: 1/2 Discriminator Loss: 1.0009441375732422 Generator Loss: 1.278185486793518
Epoch: 1/2 Discriminator Loss: 1.5870771408081055 Generator Loss: 0.8387119770050049
Epoch: 1/2 Discriminator Loss: 1.472141146659851 Generator Loss: 0.6537468433380127
Epoch: 1/2 Discriminator Loss: 1.1293425559997559 Generator Loss: 1.0387237071990967
Epoch: 1/2 Discriminator Loss: 1.180687427520752 Generator Loss: 1.3350435495376587
Epoch: 1/2 Discriminator Loss: 1.3069305419921875 Generator Loss: 0.9833154678344727
Epoch: 1/2 Discriminator Loss: 1.2213572263717651 Generator Loss: 1.1664923429489136
Epoch: 1/2 Discriminator Loss: 1.0792546272277832 Generator Loss: 1.0452792644500732
Epoch: 1/2 Discriminator Loss: 1.204624891281128 Generator Loss: 1.7370154857635498
Epoch: 1/2 Discriminator Loss: 1.082620620727539 Generator Loss: 1.0996774435043335

Epoch: 1/2 Discriminator Loss: 1.126760482788086 Generator Loss: 1.3159866333007812
Epoch: 1/2 Discriminator Loss: 1.168605089187622 Generator Loss: 1.2606281042099
Epoch: 1/2 Discriminator Loss: 1.317440390586853 Generator Loss: 1.115447759628296
Epoch: 1/2 Discriminator Loss: 1.3021074533462524 Generator Loss: 1.0721776485443115
Epoch: 1/2 Discriminator Loss: 1.2282991409301758 Generator Loss: 0.8763377666473389
Epoch: 1/2 Discriminator Loss: 1.1267790794372559 Generator Loss: 0.994697093963623
Epoch: 1/2 Discriminator Loss: 1.1833958625793457 Generator Loss: 1.3274922370910645
Epoch: 1/2 Discriminator Loss: 1.248644471168518 Generator Loss: 0.6468905210494995
Epoch: 1/2 Discriminator Loss: 1.1816861629486084 Generator Loss: 1.335179328918457
Epoch: 1/2 Discriminator Loss: 1.44919753074646 Generator Loss: 1.1259610652923584

Epoch: 1/2 Discriminator Loss: 1.0399374961853027 Generator Loss: 1.3086856603622437
Epoch: 1/2 Discriminator Loss: 1.16526198387146 Generator Loss: 1.3443944454193115
Epoch: 1/2 Discriminator Loss: 1.3787517547607422 Generator Loss: 1.2981038093566895
Epoch: 1/2 Discriminator Loss: 1.2814295291900635 Generator Loss: 0.9720869660377502
Epoch: 1/2 Discriminator Loss: 1.0493900775909424 Generator Loss: 1.471893072128296
Epoch: 1/2 Discriminator Loss: 1.1487629413604736 Generator Loss: 1.031337857246399
Epoch: 1/2 Discriminator Loss: 1.2438476085662842 Generator Loss: 1.3216118812561035
Epoch: 1/2 Discriminator Loss: 1.117708683013916 Generator Loss: 0.9196362495422363
Epoch: 1/2 Discriminator Loss: 1.2339682579040527 Generator Loss: 1.4471869468688965
Epoch: 1/2 Discriminator Loss: 1.1299030780792236 Generator Loss: 1.2027761936187744

CelebA¶

Run your GANs on CelebA. It will take around 20 minutes on the average GPU to run one epoch. You can run the whole epoch or stop when it starts to generate realistic faces.

batch_size = 16
z_dim = 100
learning_rate = 0.001
beta1 = 0.5


"""
DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
"""
epochs = 2

celeba_dataset = helper.Dataset('celeba', glob(os.path.join(data_dir, 'img_align_celeba/*.jpg')))
with tf.Graph().as_default():
    train(epochs, batch_size, z_dim, learning_rate, beta1, celeba_dataset.get_batches,
          celeba_dataset.shape, celeba_dataset.image_mode)

Epoch: 1/2 Discriminator Loss: 0.9460440874099731 Generator Loss: 2.3042988777160645
Epoch: 1/2 Discriminator Loss: 1.8139829635620117 Generator Loss: 2.1162109375
Epoch: 1/2 Discriminator Loss: 1.9752377271652222 Generator Loss: 0.9932956695556641
Epoch: 1/2 Discriminator Loss: 1.9784797430038452 Generator Loss: 0.5090080499649048
Epoch: 1/2 Discriminator Loss: 1.3638492822647095 Generator Loss: 2.0168697834014893
Epoch: 1/2 Discriminator Loss: 0.823479413986206 Generator Loss: 2.1556930541992188
Epoch: 1/2 Discriminator Loss: 0.8851373195648193 Generator Loss: 1.756004810333252
Epoch: 1/2 Discriminator Loss: 1.115199327468872 Generator Loss: 0.9934808015823364
Epoch: 1/2 Discriminator Loss: 0.6028454303741455 Generator Loss: 4.018949508666992
Epoch: 1/2 Discriminator Loss: 1.726462721824646 Generator Loss: 0.5380561947822571

Epoch: 1/2 Discriminator Loss: 1.021604061126709 Generator Loss: 1.2969255447387695
Epoch: 1/2 Discriminator Loss: 1.1293892860412598 Generator Loss: 2.829901695251465
Epoch: 1/2 Discriminator Loss: 1.1679208278656006 Generator Loss: 2.61077880859375
Epoch: 1/2 Discriminator Loss: 0.9795941710472107 Generator Loss: 1.1757328510284424
Epoch: 1/2 Discriminator Loss: 0.7134943008422852 Generator Loss: 1.8702976703643799
Epoch: 1/2 Discriminator Loss: 1.1943917274475098 Generator Loss: 0.9743534326553345
Epoch: 1/2 Discriminator Loss: 1.5739128589630127 Generator Loss: 0.87705397605896
Epoch: 1/2 Discriminator Loss: 1.7001581192016602 Generator Loss: 0.5748404860496521
Epoch: 1/2 Discriminator Loss: 1.0900226831436157 Generator Loss: 1.9057176113128662
Epoch: 1/2 Discriminator Loss: 1.9547927379608154 Generator Loss: 0.817375898361206

Epoch: 1/2 Discriminator Loss: 0.8346681594848633 Generator Loss: 1.6680963039398193
Epoch: 1/2 Discriminator Loss: 1.837680459022522 Generator Loss: 0.7112544775009155
Epoch: 1/2 Discriminator Loss: 2.0007290840148926 Generator Loss: 0.8403967022895813
Epoch: 1/2 Discriminator Loss: 0.8146247863769531 Generator Loss: 1.2387104034423828
Epoch: 1/2 Discriminator Loss: 2.187096118927002 Generator Loss: 0.5653785467147827
Epoch: 1/2 Discriminator Loss: 1.575423002243042 Generator Loss: 0.44610536098480225
Epoch: 1/2 Discriminator Loss: 0.8061478137969971 Generator Loss: 1.4025094509124756
Epoch: 1/2 Discriminator Loss: 0.765648365020752 Generator Loss: 1.8694474697113037
Epoch: 1/2 Discriminator Loss: 1.04823637008667 Generator Loss: 1.1857610940933228
Epoch: 1/2 Discriminator Loss: 1.398970365524292 Generator Loss: 0.7853888273239136

Epoch: 1/2 Discriminator Loss: 1.2837954759597778 Generator Loss: 0.9661429524421692
Epoch: 1/2 Discriminator Loss: 0.7778340578079224 Generator Loss: 1.7270488739013672
Epoch: 1/2 Discriminator Loss: 0.7462895512580872 Generator Loss: 1.6926603317260742
Epoch: 1/2 Discriminator Loss: 1.1977694034576416 Generator Loss: 1.0718095302581787
Epoch: 1/2 Discriminator Loss: 1.5074795484542847 Generator Loss: 1.3708423376083374
Epoch: 1/2 Discriminator Loss: 0.6674611568450928 Generator Loss: 1.9379234313964844
Epoch: 1/2 Discriminator Loss: 1.422972559928894 Generator Loss: 0.8688852787017822
Epoch: 1/2 Discriminator Loss: 1.0767854452133179 Generator Loss: 1.0928012132644653
Epoch: 1/2 Discriminator Loss: 1.1278109550476074 Generator Loss: 1.2925935983657837
Epoch: 1/2 Discriminator Loss: 1.304538607597351 Generator Loss: 1.2598921060562134

Epoch: 1/2 Discriminator Loss: 1.2015902996063232 Generator Loss: 1.2434625625610352
Epoch: 1/2 Discriminator Loss: 1.2733347415924072 Generator Loss: 0.8091722726821899
Epoch: 1/2 Discriminator Loss: 1.5423483848571777 Generator Loss: 0.8629216551780701
Epoch: 1/2 Discriminator Loss: 1.0935983657836914 Generator Loss: 1.2402387857437134
Epoch: 1/2 Discriminator Loss: 1.146706223487854 Generator Loss: 1.0306907892227173
Epoch: 1/2 Discriminator Loss: 1.6483482122421265 Generator Loss: 0.6367099285125732
Epoch: 1/2 Discriminator Loss: 1.2371313571929932 Generator Loss: 0.8913639783859253
Epoch: 1/2 Discriminator Loss: 1.3202030658721924 Generator Loss: 0.8428338766098022
Epoch: 1/2 Discriminator Loss: 1.3996760845184326 Generator Loss: 0.9476930499076843
Epoch: 1/2 Discriminator Loss: 1.4043625593185425 Generator Loss: 1.2610790729522705

Epoch: 1/2 Discriminator Loss: 1.5076112747192383 Generator Loss: 0.6782893538475037
Epoch: 1/2 Discriminator Loss: 1.4219262599945068 Generator Loss: 0.8581255674362183
Epoch: 1/2 Discriminator Loss: 1.499443769454956 Generator Loss: 1.1349008083343506
Epoch: 1/2 Discriminator Loss: 1.3587349653244019 Generator Loss: 0.7833026647567749
Epoch: 1/2 Discriminator Loss: 1.2603530883789062 Generator Loss: 0.9133014678955078
Epoch: 1/2 Discriminator Loss: 1.1181938648223877 Generator Loss: 1.1688023805618286
Epoch: 1/2 Discriminator Loss: 1.6563878059387207 Generator Loss: 0.9244906306266785
Epoch: 1/2 Discriminator Loss: 1.343045949935913 Generator Loss: 0.7209442853927612
Epoch: 1/2 Discriminator Loss: 1.8129185438156128 Generator Loss: 0.6665418148040771
Epoch: 1/2 Discriminator Loss: 1.2584270238876343 Generator Loss: 1.1083221435546875

Epoch: 1/2 Discriminator Loss: 1.616091251373291 Generator Loss: 0.48106738924980164
Epoch: 1/2 Discriminator Loss: 1.0145965814590454 Generator Loss: 0.9045995473861694
Epoch: 1/2 Discriminator Loss: 1.2348321676254272 Generator Loss: 1.0825773477554321
Epoch: 1/2 Discriminator Loss: 1.3059483766555786 Generator Loss: 1.0672595500946045
Epoch: 1/2 Discriminator Loss: 1.267271637916565 Generator Loss: 0.9131679534912109
Epoch: 1/2 Discriminator Loss: 1.6104227304458618 Generator Loss: 0.6948156356811523
Epoch: 1/2 Discriminator Loss: 1.3387954235076904 Generator Loss: 0.9359984993934631
Epoch: 1/2 Discriminator Loss: 1.3759686946868896 Generator Loss: 0.7382140755653381
Epoch: 1/2 Discriminator Loss: 1.3137801885604858 Generator Loss: 1.3530038595199585
Epoch: 1/2 Discriminator Loss: 1.028510332107544 Generator Loss: 0.6973156929016113

Epoch: 1/2 Discriminator Loss: 1.5780223608016968 Generator Loss: 0.6177055835723877
Epoch: 1/2 Discriminator Loss: 1.2864089012145996 Generator Loss: 1.09827721118927
Epoch: 1/2 Discriminator Loss: 1.576740026473999 Generator Loss: 1.1169390678405762
Epoch: 1/2 Discriminator Loss: 1.3174068927764893 Generator Loss: 0.6902238726615906
Epoch: 1/2 Discriminator Loss: 1.3484218120574951 Generator Loss: 0.7085843086242676
Epoch: 1/2 Discriminator Loss: 1.3829751014709473 Generator Loss: 0.909600019454956
Epoch: 1/2 Discriminator Loss: 1.5980522632598877 Generator Loss: 0.6297208070755005
Epoch: 1/2 Discriminator Loss: 1.5239379405975342 Generator Loss: 0.9249875545501709
Epoch: 1/2 Discriminator Loss: 1.3442400693893433 Generator Loss: 1.1330007314682007
Epoch: 1/2 Discriminator Loss: 1.5055657625198364 Generator Loss: 0.8777049779891968

Epoch: 1/2 Discriminator Loss: 1.0790178775787354 Generator Loss: 0.849831223487854
Epoch: 1/2 Discriminator Loss: 1.223854660987854 Generator Loss: 0.9558955430984497
Epoch: 1/2 Discriminator Loss: 1.4136152267456055 Generator Loss: 1.1239821910858154
Epoch: 1/2 Discriminator Loss: 1.3193557262420654 Generator Loss: 0.9085462093353271
Epoch: 1/2 Discriminator Loss: 1.6086974143981934 Generator Loss: 0.8205769062042236
Epoch: 1/2 Discriminator Loss: 1.386099100112915 Generator Loss: 0.7442167401313782
Epoch: 1/2 Discriminator Loss: 1.3620967864990234 Generator Loss: 1.1319471597671509
Epoch: 1/2 Discriminator Loss: 1.2231606245040894 Generator Loss: 1.0747675895690918
Epoch: 1/2 Discriminator Loss: 1.4668428897857666 Generator Loss: 1.063456416130066
Epoch: 1/2 Discriminator Loss: 1.4952378273010254 Generator Loss: 0.774412989616394

Epoch: 1/2 Discriminator Loss: 1.3519127368927002 Generator Loss: 1.0575535297393799
Epoch: 1/2 Discriminator Loss: 1.673980951309204 Generator Loss: 0.5915200114250183
Epoch: 1/2 Discriminator Loss: 1.8668498992919922 Generator Loss: 0.6379939317703247
Epoch: 1/2 Discriminator Loss: 1.6343069076538086 Generator Loss: 0.7609826922416687
Epoch: 1/2 Discriminator Loss: 1.450516939163208 Generator Loss: 0.6903630495071411
Epoch: 1/2 Discriminator Loss: 1.270506501197815 Generator Loss: 0.8524201512336731
Epoch: 1/2 Discriminator Loss: 1.376383900642395 Generator Loss: 0.8131948113441467
Epoch: 1/2 Discriminator Loss: 1.3307578563690186 Generator Loss: 0.922895610332489
Epoch: 1/2 Discriminator Loss: 1.3416081666946411 Generator Loss: 0.9338025450706482
Epoch: 1/2 Discriminator Loss: 1.4311391115188599 Generator Loss: 0.8391862511634827

Submitting This Project¶

When submitting this project, make sure to run all the cells before saving the notebook. Save the notebook file as "dlnd_face_generation.ipynb" and save it as a HTML file under "File" -> "Download as". Include the "helper.py" and "problem_unittests.py" files in your submission.